Let's Get Rusty | Rust Developer Bootcamp [FCO]
- Type:
- Other > Other
- Files:
- 109
- Size:
- 2.9 GiB (3117368497 Bytes)
- Uploaded:
- 2024-01-28 20:16:42 GMT
- By:
-
Prom3th3uS
- Seeders:
- 9
- Leechers:
- 0
- Comments
- 0
- Info Hash: 7CC772D05BCB5465EDA218961E72F2A87CC34C68
(Problems with magnets links are fixed by upgrading your torrent client!)
Lynda and other Courses >>> https://freecoursesonline.me/ Forum for discussion >>> https://onehack.us/ https://get.freecoursesonline.me/wp-content/uploads/2024/01/lets-get-rusty.png Let's Get Rusty - Rust Developer Bootcamp [FCO] About Lets Get Rusty - Bootcamp for Rust developers Who is this bootcamp for? Experienced developers who want to switch to Rust. Learn the language of the future. Your time is valuable ($148,688/year, literally). Learn Rust FAST with a bootcamp instead of digging through poor quality resources. Students/Graduates looking for work. Learning Rust is a great addition to a resume. Stand out from other candidates. Become a competent programmer. Gain access to a community that can help you find your first job. And you! Rust enthusiast. Rust is an innovative language that will expand your thinking! Cutting-edge technologies are created in Rust. You will learn how to set up your development environment, configure your development environment (IDE), and install the necessary plugins. Then you'll create your first Rust project! You will learn: • How to Set Up Your Development Environment • Setting up your IDE and plugins • Creating Rust Packages Using Cargo • Variables and Data Types in Rust • Constant and static variables • Functions and Flow Control Understanding memory management is critical when learning Rust! In this section, you'll learn about memory management from the very beginning! You will learn: • Computer Science Masterclass Based on Rust • How does the ownership mechanism work? • How does the borrowing mechanism work? • What are slices • String types (str, &str and String) Rust doesn't use classes or objects! Instead, Rust uses Structs and Enums to create custom data types. In this section, you'll learn how to create your own types! You will learn: • How to create structures and enumerations • How to use implementation blocks • Pattern matching • Option and Result enumerations • Vectors How to Structure Your Rust Projects In this section, I will explain how modules work in a clear way. I'll also talk about structuring larger projects and publishing your work on Crates.io. You will learn: • Project structure overview • Module system • External dependencies • Conditional compilation • How to structure large projects • Publishing your projects in Rust How to Test and Document Your Code Tests are a critical part of writing reliable code. In this section, you'll learn how to write and structure unit and integration tests in Rust. We will also look at documentation issues. You will learn: • How to Write Unit Tests • How to write integration tests • How to structure your tests • Comments on the documentation Polymorphism Using Generics and Traits Rust doesn't support classical inheritance! Instead, polymorphism is achieved through generics and traits. In this section, you will learn how both of these mechanisms work. You will learn: • How to identify generics • Trait system • Trait Boundaries and Trait Objects • Supertraits • Static dispatching vs dynamic dispatching • How to display traits • Traits in the standard library Advanced Memory Management Memory management doesn't end with owning and borrowing mechanisms! In this section you will learn about lifetimes! We'll also look at various smart pointers in Rust. You will learn: • Concrete Lifetimes • Generic Lifetimes Annotations • Lifetimes in functions and structures • Smart pointers and why they are useful • Implicit Deref Coercion Understanding Error Handling in Rust Understanding error handling is critical when designing your Rust applications. In this section, we'll look at how error handling works in Rust. You will learn: • How to generate uncorrectable errors • How to return correctable errors • How to propagate bugs • Result and Option enumerations • How to Handle Many Types of Errors • How to use anyhow and thiserror Functional Features in Rust One of the most powerful features of Rust is its functionality. In this section, we'll look at closures, function pointers, iterators, and more! You will learn: • Closures and function pointers • Iterator Pattern in Rust • Implementing the Iterator Pattern • How to iterate through collections • Combinators and how to use them Concurrency and async/.await This is probably the MOST IMPORTANT section. Understanding concurrency is critical, especially when using Rust for web projects. You will learn: • Basic Concurrency Concepts • Creating Threads • Messaging using channels • Sharing State with Mutex • async/.await model • How Futures work (future results) • What is asynchronous execution • What is Tokio and how is it used? • What are Tokio tasks • Executing CPU-Blocking Code • Data Streams Rust's Powerful Macro System Macros are an extremely powerful way to extend the syntax of a language. In this section, you'll learn about Rust's macro system from the very beginning! • Compilation process • What are macros • How to Create Declarative Macros • How to Create Procedural Macros • Function-like procedural macros • Attribute-like procedural macros • Custom procedural macros based on derived types (Custom Derive) Insecure Rust and FFI (Foreign Function Interface) One of Rust's significant advantages is its ability to interact with other languages through an external function interface. In this section you will learn about insecure Rust and FFI! You will learn: • Insecure Rust and when to use it • How to dereference raw pointers • What are unsafe functions • What are unsafe traits? • How to change static variables • How to Write Assembly Inline Commands in Rust • How to Call C Code from Rust • How to Call Rust Code from C Instructor: Hi, I'm Bogdan, the founder of Let's Get Rusty, and I will personally be running this bootcamp. My journey learning Rust was *far* from smooth or easy. I did not have a traditional 4 year computer science degree. And although I worked for a large technology company (Salesforce), my focus has always been on front-end development. So I was completely new to low level programming. Also, when I started, there weren't many beginner-friendly resources for learning Rust. My journey of learning Rust was long and painful... But I never gave up! I never made excuses and always kept moving forward. My experience learning Rust inspired me to help others... Media Information: MP4 | Video: h264, 1920x1080p | Audio: AAC, 44.100 KHz, 2 Ch Genre: eLearning | Language: English | Last updated: 01/05/2024 | Duration: 105 lectures ( 9h 50m 20s ) | Author: Bogdan Course Source: https://checkout.letsgetrusty.com/bootcamp
| 0. Websites you may like/1. OneHack.us Premium Cracked Accounts-Tutorials-Guides-Articles Community Based Forum.url | 377 B |
| 0. Websites you may like/2. FTUApps.com Download Cracked Developers Applications For Free.url | 239 B |
| 001. Don't skip this video!.mp4 | 146.57 MiB |
| 002. How to use this Bootcamp effectively.mp4 | 111.17 MiB |
| 003. Hello World.mp4 | 8.54 MiB |
| 004. Variables.mp4 | 10.13 MiB |
| 005. Data Types.mp4 | 13.94 MiB |
| 006. Constants & Statics.mp4 | 6.56 MiB |
| 007. Functions.mp4 | 9.89 MiB |
| 008. Control Flow.mp4 | 11.54 MiB |
| 009. Comments.mp4 | 2.2 MiB |
| 010. Stack, Heap, and Static Memory.mp4 | 26.23 MiB |
| 011. Memory Management Strategies.mp4 | 13.61 MiB |
| 012. C++ RAII vs Rust OBRM - Part 1.mp4 | 49.66 MiB |
| 013. C++ RAII vs Rust OBRM - Part 2.mp4 | 26.06 MiB |
| 014. Ownership.mp4 | 25.78 MiB |
| 015. Ownership Continued.mp4 | 34.17 MiB |
| 016. Borrowing.mp4 | 43.11 MiB |
| 017. Slices.mp4 | 40.49 MiB |
| 018. BONUS Masterclass Strings in Rust. PART 1.mp4 | 67.82 MiB |
| 019. BONUS Masterclass Strings in Rust. PART 2.mp4 | 70.87 MiB |
| 020. Structs.mp4 | 12.57 MiB |
| 021. Implementation Blocks.mp4 | 31.89 MiB |
| 022. Tuple Structs.mp4 | 5.95 MiB |
| 023. Enums.mp4 | 22.67 MiB |
| 024. Matching.mp4 | 33.32 MiB |
| 025. Option.mp4 | 23.58 MiB |
| 026. Result.mp4 | 20.53 MiB |
| 027. Vectors.mp4 | 27.25 MiB |
| 028. Project Structure Overview.mp4 | 22.04 MiB |
| 029. Modules.mp4 | 67.25 MiB |
| 030. Modules Continued.mp4 | 40.44 MiB |
| 031. External Dependencies.mp4 | 17.76 MiB |
| 032. Publishing Your Package.mp4 | 28.03 MiB |
| 033. Cargo Features.mp4 | 28.46 MiB |
| 034. Cargo Workspaces.mp4 | 21.55 MiB |
| 035. Unit Tests.mp4 | 57.32 MiB |
| 036. Integration Tests.mp4 | 18.13 MiB |
| 037. Documentation.mp4 | 10.82 MiB |
| 038. BONUS Benchmark Testing.mp4 | 21.27 MiB |
| 039. Generics.mp4 | 54.19 MiB |
| 040. Traits.mp4 | 25.11 MiB |
| 041. Trait Bounds.mp4 | 24.88 MiB |
| 042. Supertraits.mp4 | 7.7 MiB |
| 043. Trait Objects.mp4 | 32.06 MiB |
| 044. Deriving Traits.mp4 | 11.42 MiB |
| 045. The Orphan Rule.mp4 | 13.88 MiB |
| 046. Concrete Lifetimes.mp4 | 20.36 MiB |
| 047. Generic Lifetimes.mp4 | 40.38 MiB |
| 048. Structs & Lifetime Elision.mp4 | 40.31 MiB |
| 049. Box Smart Pointer.mp4 | 25.5 MiB |
| 050. Rc Smart Pointer.mp4 | 15.02 MiB |
| 051. RefCell Smart Pointer.mp4 | 24.51 MiB |
| 052. Deref Coercion.mp4 | 26.62 MiB |
| 053. Unrecoverable Errors.mp4 | 9.15 MiB |
| 054. Recoverable Errors.mp4 | 16.37 MiB |
| 055. Propagating Errors.mp4 | 20.42 MiB |
| 056. Result and Option.mp4 | 21.01 MiB |
| 057. Multiple Error Types.mp4 | 27.31 MiB |
| 058. Overview of Error Handling.mp4 | 14.87 MiB |
| 059. Basic Error Handling.mp4 | 61.49 MiB |
| 060. Custom Errors 1.mp4 | 36.53 MiB |
| 061. Custom Errors 2.mp4 | 52.73 MiB |
| 062. Custom Errors 3.mp4 | 43.6 MiB |
| 063. thiserror & anyhow.mp4 | 32.1 MiB |
| 064. BONUS error-stack.mp4 | 141.83 MiB |
| 065. Closures.mp4 | 68.48 MiB |
| 066. Closures Continued.mp4 | 32 MiB |
| 067. Function Pointers.mp4 | 18.93 MiB |
| 068. Iterator Pattern.mp4 | 28.17 MiB |
| 069. Iterator Pattern Continued.mp4 | 26.11 MiB |
| 070. Iterating Over Collections.mp4 | 9.61 MiB |
| 071. Combinators.mp4 | 52.03 MiB |
| 072. Intro to Concurrency.mp4 | 29.68 MiB |
| 073. Creating Threads.mp4 | 15.81 MiB |
| 074. Moving Values Into Threads.mp4 | 3.81 MiB |
| 075. Message Passing Between Threads.mp4 | 23.89 MiB |
| 076. Sharing State Between Threads.mp4 | 11.94 MiB |
| 077. Sharing State Between Threads Continued.mp4 | 18.01 MiB |
| 078. Send & Sync Traits.mp4 | 10.37 MiB |
| 079. async.await Basics.mp4 | 35.83 MiB |
| 080. Tokio Tasks.mp4 | 23.67 MiB |
| 081. CPU Intensive Code.mp4 | 11.04 MiB |
| 082. Streams.mp4 | 8.44 MiB |
| 083. Intro to Macros.mp4 | 17.97 MiB |
| 084. Declarative Macros.mp4 | 11.99 MiB |
| 085. Declarative Macros Continued.mp4 | 28.92 MiB |
| 086. Procedural Macros.mp4 | 6.47 MiB |
| 087. Procedural Macros - Function Like.mp4 | 20.96 MiB |
| 088. Procedural Macros - Custom Derive.mp4 | 34.15 MiB |
| 089. Procedural Macros - Attribute Like.mp4 | 39.21 MiB |
| 090. Procedural Macros - Attribute Continued.mp4 | 40.35 MiB |
| 091. Unsafe Basics.mp4 | 5.02 MiB |
| 092. Dereferencing a Raw Pointer.mp4 | 10.52 MiB |
| 093. Calling an Unsafe Function.mp4 | 6.56 MiB |
| 094. Implementing an Unsafe Trait.mp4 | 8.88 MiB |
| 095. Mutable Static Variables.mp4 | 5.3 MiB |
| 096. Inline Assembly.mp4 | 4.43 MiB |
| 097. FFI C from Rust.mp4 | 13.63 MiB |
| 098. FFI Rust from C.mp4 | 7.52 MiB |
| 099. BONUS FFI Rust from Python.mp4 | 42.36 MiB |
| 100. What are microservices.mp4 | 14.94 MiB |
| 101. Why Rust is great for microservices.mp4 | 5 MiB |
| 102. Communication with gRPC.mp4 | 16.29 MiB |
| 103. Containerization with Docker.mp4 | 120.1 MiB |
| 104. CICD with GitHub Actions.mp4 | 6.28 MiB |
| 105. Cloud Providers.mp4 | 9.79 MiB |
| FreeCoursesOnline.me Download Udacity, Masterclass, Lynda, PHLearn, etc Free.url | 29 B |
| Support Us.txt | 185 B |
